package com.aviatorscript.aviatorscript.controller;

import com.aviatorscript.aviatorscript.common.Result;
import com.aviatorscript.aviatorscript.dto.TransformRuleDTO;
import com.aviatorscript.aviatorscript.service.TransformRuleService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

/**
 * 转换规则控制器
 * 提供转换规则管理的REST API接口
 */
@Slf4j
@RestController
@RequestMapping("/api/transform/rules")
public class TransformRuleController {

    @Autowired
    private TransformRuleService transformRuleService;

    /**
     * 创建转换规则
     * @param ruleDTO 转换规则DTO
     * @return 创建结果
     */
    @PostMapping
    public Result<TransformRuleDTO> createRule(@RequestBody TransformRuleDTO ruleDTO) {
        log.info("接收到创建转换规则请求: {}", ruleDTO.getRuleCode());
        
        try {
            TransformRuleDTO result = transformRuleService.createRule(ruleDTO);
            return Result.success("转换规则创建成功", result);
        } catch (Exception e) {
            log.error("创建转换规则失败", e);
            return Result.error("创建转换规则失败: " + e.getMessage());
        }
    }

    /**
     * 更新转换规则
     * @param id 规则ID
     * @param ruleDTO 转换规则DTO
     * @return 更新结果
     */
    @PutMapping("/{id}")
    public Result<TransformRuleDTO> updateRule(@PathVariable Long id, @RequestBody TransformRuleDTO ruleDTO) {
        log.info("接收到更新转换规则请求，ID: {}", id);
        
        try {
            ruleDTO.setId(id); // 确保DTO中的ID与路径参数一致
            TransformRuleDTO result = transformRuleService.updateRule(ruleDTO);
            return Result.success("转换规则更新成功", result);
        } catch (Exception e) {
            log.error("更新转换规则失败，ID: {}", id, e);
            return Result.error("更新转换规则失败: " + e.getMessage());
        }
    }

    /**
     * 删除转换规则
     * @param id 规则ID
     * @return 删除结果
     */
    @DeleteMapping("/{id}")
    public Result<Void> deleteRule(@PathVariable Long id) {
        log.info("接收到删除转换规则请求，ID: {}", id);
        
        try {
            transformRuleService.deleteRule(id);
            return Result.success();
        } catch (Exception e) {
            log.error("删除转换规则失败，ID: {}", id, e);
            return Result.error("删除转换规则失败: " + e.getMessage());
        }
    }

    /**
     * 根据ID查询转换规则
     * @param id 规则ID
     * @return 转换规则详情
     */
    @GetMapping("/{id}")
    public Result<TransformRuleDTO> getRuleById(@PathVariable Long id) {
        log.debug("接收到查询转换规则请求，ID: {}", id);
        
        try {
            TransformRuleDTO rule = transformRuleService.getRuleById(id);
            if (rule == null) {
                return Result.error(404, "转换规则不存在");
            }
            return Result.success("查询成功", rule);
        } catch (Exception e) {
            log.error("查询转换规则失败，ID: {}", id, e);
            return Result.error("查询转换规则失败: " + e.getMessage());
        }
    }

    /**
     * 根据规则编码查询转换规则
     * @param ruleCode 规则编码
     * @return 转换规则详情
     */
    @GetMapping("/code/{ruleCode}")
    public Result<TransformRuleDTO> getRuleByCode(@PathVariable String ruleCode) {
        log.debug("接收到查询转换规则请求，规则编码: {}", ruleCode);
        
        try {
            TransformRuleDTO rule = transformRuleService.getRuleByCode(ruleCode);
            if (rule == null) {
                return Result.error(404, "转换规则不存在");
            }
            return Result.success("查询成功", rule);
        } catch (Exception e) {
            log.error("查询转换规则失败，规则编码: {}", ruleCode, e);
            return Result.error("查询转换规则失败: " + e.getMessage());
        }
    }

    /**
     * 分页查询转换规则列表
     * @param page 页码（默认1）
     * @param size 页面大小（默认10）
     * @param enabled 是否启用（可选）
     * @param keyword 关键词搜索（可选）
     * @return 转换规则分页列表
     */
    @GetMapping
    public Result<IPage<TransformRuleDTO>> getRuleList(
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "10") int size,
            @RequestParam(required = false) Boolean enabled,
            @RequestParam(required = false) String keyword) {
        
        log.debug("接收到分页查询转换规则请求，page: {}, size: {}, enabled: {}, keyword: {}", 
                page, size, enabled, keyword);
        
        try {
            IPage<TransformRuleDTO> result = transformRuleService.getRuleList(page, size, enabled, keyword);
            return Result.success("查询成功", result);
        } catch (Exception e) {
            log.error("分页查询转换规则失败", e);
            return Result.error("分页查询转换规则失败: " + e.getMessage());
        }
    }

    /**
     * 启用/禁用转换规则
     * @param id 规则ID
     * @param enabled 是否启用
     * @return 操作结果
     */
    @PutMapping("/{id}/status")
    public Result<Void> updateRuleStatus(@PathVariable Long id, @RequestParam Boolean enabled) {
        log.info("接收到更新规则状态请求，ID: {}, enabled: {}", id, enabled);
        
        try {
            transformRuleService.updateRuleStatus(id, enabled);
            return Result.success();
        } catch (Exception e) {
            log.error("更新规则状态失败，ID: {}", id, e);
            return Result.error("更新规则状态失败: " + e.getMessage());
        }
    }

    /**
     * 执行数据转换
     * @param ruleCode 规则编码
     * @param requestBody 包含源数据和目标类型的请求体
     * @return 转换结果
     */
    @PostMapping("/execute/{ruleCode}")
    public Result<Object> executeTransform(@PathVariable String ruleCode, @RequestBody Map<String, Object> requestBody) {
        log.info("接收到数据转换请求，规则编码: {}", ruleCode);
        
        try {
            // 从请求体中获取源数据
            Object sourceData = requestBody.get("sourceData");
            String targetClassName = (String) requestBody.get("targetClass");
            
            if (sourceData == null) {
                return Result.error("源数据不能为空");
            }
            if (targetClassName == null || targetClassName.trim().isEmpty()) {
                return Result.error("目标类型不能为空");
            }

            // 通过反射获取目标类型
            Class<?> targetClass = Class.forName(targetClassName);
            
            // 执行转换
            Object result = transformRuleService.executeTransform(ruleCode, sourceData, targetClass);
            
            return Result.success("数据转换成功", result);
        } catch (ClassNotFoundException e) {
            log.error("目标类型不存在: {}", requestBody.get("targetClass"), e);
            return Result.error("目标类型不存在: " + requestBody.get("targetClass"));
        } catch (Exception e) {
            log.error("数据转换失败，规则编码: {}", ruleCode, e);
            return Result.error("数据转换失败: " + e.getMessage());
        }
    }

    /**
     * 刷新指定规则缓存
     * @param ruleCode 规则编码
     * @return 操作结果
     */
    @PostMapping("/cache/refresh/{ruleCode}")
    public Result<Void> refreshRuleCache(@PathVariable String ruleCode) {
        log.info("接收到刷新规则缓存请求，规则编码: {}", ruleCode);
        
        try {
            transformRuleService.refreshRuleCache(ruleCode);
            return Result.success();
        } catch (Exception e) {
            log.error("刷新规则缓存失败，规则编码: {}", ruleCode, e);
            return Result.error("刷新规则缓存失败: " + e.getMessage());
        }
    }

    /**
     * 刷新所有规则缓存
     * @return 操作结果
     */
    @PostMapping("/cache/refresh")
    public Result<Void> refreshAllRulesCache() {
        log.info("接收到刷新所有规则缓存请求");
        
        try {
            transformRuleService.refreshAllRulesCache();
            return Result.success();
        } catch (Exception e) {
            log.error("刷新所有规则缓存失败", e);
            return Result.error("刷新所有规则缓存失败: " + e.getMessage());
        }
    }
} 